home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / kernel / sources / kr_pat_parse.y < prev    next >
Encoding:
Text File  |  1994-04-25  |  8.3 KB  |  408 lines
  1. /*****************************************************************************
  2.   FILE           : kr_pat_parse.y
  3.   SHORTNAME      : pat_parse
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : parser for new pattern format; bison format 
  7.   NOTES          : impossible to use with yacc
  8.  
  9.   AUTHOR         : Michael Vogt
  10.   DATE           : 10.9.93
  11.  
  12.   CHANGED BY     : 
  13.   IDENTIFICATION : @(#)kr_pat_parse.y    1.4 4/14/94
  14.   SCCS VERSION   : 1.4
  15.   LAST CHANGE    : 4/14/94
  16.  
  17.              Copyright (c) 1990-1993  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.  
  19. ******************************************************************************/
  20. %{
  21. #include <stdio.h>
  22.  
  23. /* since the generated parser needs alloca we need to do some special things */
  24. /* for some architectures: */
  25.  
  26. #ifndef alloca
  27. #ifndef __GNUC__
  28.  
  29. #ifdef __hpux
  30. #include <malloc.h>
  31. #include <stdio.h>
  32. #endif /* __hpux */
  33.  
  34. #ifdef sparc
  35. #include <alloca.h>
  36. #endif /* sparc */
  37.  
  38. #endif /* GNU C. not defined  */
  39. #endif /* alloca not defined.  */
  40.  
  41. #include "kr_typ.h"
  42. #include "glob_typ.h"
  43. #include "kernel.h"
  44. #include "kr_pat_scan.h"
  45. #include "kr_newpattern.h"
  46. #include "kr_pat_parse.ph"
  47. %}
  48.  
  49. %union
  50. {
  51.     float    value;        /* allgemeine Zahl */    
  52.     struct
  53.     {
  54.         int    v;
  55.         int    r;
  56.     }    version;    /* Versionsnummer #.# */
  57. }
  58.  
  59. %token    L_BRACKET R_BRACKET
  60. %token    VERSION_HEADER
  61. %token    GENERATED_AT
  62. %token    NO_OF_PATTERN NO_OF_INPUT NO_OF_OUTPUT
  63. %token    NO_OF_VAR_IDIM NO_OF_VAR_ODIM
  64. %token    MAXIMUM_IDIM MAXIMUM_ODIM
  65. %token    ERROR PATTERNEND
  66.  
  67. %token    <value> NUMBER
  68. %token    <version> V_NUMBER
  69.  
  70. %%
  71.  
  72. pattern_file:    header
  73.         {    
  74.             current_pattern = 0;
  75.             next_pattern_is_input = 1;
  76.  
  77.             if (kr_np_AllocatePatternSet(&pattern_set, no_of_pattern)
  78.             != KRERR_NO_ERROR)
  79.             { 
  80.             yyerror("can't allocate memory"); 
  81.             YYABORT; 
  82.             }
  83.         }        
  84.         pattern_list
  85.         {
  86.             if (current_pattern < no_of_pattern ||
  87.             !next_pattern_is_input)
  88.             { 
  89.             yyerror("unexpected end of file"); 
  90.             YYABORT; 
  91.             }
  92.         }
  93. ;
  94.  
  95. header:    VERSION_HEADER V_NUMBER 
  96.     {
  97.         if (($2.v == CURRENT_VERSION_V && $2.r > CURRENT_VERSION_R) ||
  98.             $2.v > CURRENT_VERSION_V)
  99.         { 
  100.             yyerror("version of pattern file not supported"); 
  101.             YYABORT; 
  102.         }
  103.     }
  104.     GENERATED_AT NO_OF_PATTERN NUMBER
  105.     {
  106.         no_of_pattern = (int) $6;
  107.         if (no_of_pattern <= 0)
  108.         { 
  109.             yyerror("illegal number of pattern"); 
  110.             YYABORT; 
  111.         }
  112.     }
  113.         i_head o_head vi_head vo_head
  114. ;
  115.  
  116. i_head:    NO_OF_INPUT NUMBER
  117.     { 
  118.         no_of_input = (int) $2;
  119.         if (no_of_input < 0)
  120.         { 
  121.             yyerror("illegal number of input units"); 
  122.             YYABORT; 
  123.         } 
  124.     }
  125. ;
  126.  
  127. o_head:    NO_OF_OUTPUT NUMBER
  128.     { 
  129.         no_of_output = (int) $2;
  130.         if (no_of_output < 0)
  131.         { 
  132.             yyerror("illegal number of output units"); 
  133.             YYABORT; 
  134.         } 
  135.     }
  136.     |
  137.     { no_of_output = 0; }
  138. ;
  139.  
  140. vi_head: NO_OF_VAR_IDIM NUMBER MAXIMUM_IDIM actual_dim
  141.     {
  142.         variable_input_dim = $2; 
  143.         if (variable_input_dim < 0 || 
  144.             variable_input_dim > MAX_NO_OF_VAR_I_DIM)
  145.         { 
  146.             yyerror("illegal variable input dimensions"); 
  147.             YYABORT; 
  148.         }
  149.         if (actual_dim_count != variable_input_dim)
  150.         { 
  151.             yyerror("illegal number of entries in dimension list"); 
  152.             YYABORT; 
  153.         }
  154.         for (i=0; i<variable_input_dim; i++)
  155.             max_i_dims[i] = dims[i];
  156.     }
  157.     |
  158.     { variable_input_dim = 0; }
  159. ;
  160.  
  161. vo_head: NO_OF_VAR_ODIM NUMBER MAXIMUM_ODIM actual_dim
  162.     {
  163.         variable_output_dim = $2; 
  164.         if (variable_output_dim < 0 || 
  165.             variable_output_dim > MAX_NO_OF_VAR_O_DIM ||
  166.             no_of_output == 0)
  167.         { 
  168.             yyerror("illegal variable output dimensions"); 
  169.             YYABORT; 
  170.         }
  171.         if (actual_dim_count != variable_output_dim)
  172.         { 
  173.             yyerror("illegal number of entries in dimension list"); 
  174.             YYABORT; 
  175.         }
  176.         for (i=0; i<variable_output_dim; i++)
  177.             max_o_dims[i] = dims[i];    
  178.     }
  179.     |
  180.     { variable_output_dim = 0; }
  181. ;
  182.  
  183. actual_dim: L_BRACKET 
  184.         {
  185.             actual_dim_count = 0;
  186.         }
  187.         actual_dim_rest R_BRACKET
  188.         | L_BRACKET R_BRACKET                
  189.                 {
  190.                 actual_dim_count = 0;
  191.         }
  192. ;
  193.  
  194. actual_dim_rest: dim_entry
  195.     | actual_dim_rest dim_entry
  196. ;
  197.  
  198. dim_entry: NUMBER
  199.     {
  200.         if (actual_dim_count >= MAX_NO_OF_VAR_DIM)
  201.         { 
  202.             yyerror("to many entries in dimension list"); 
  203.             YYABORT; 
  204.         }
  205.         dims[actual_dim_count] = (int) $1;
  206.         if (dims[actual_dim_count] <= 0)
  207.         { 
  208.             yyerror("illegal size of dimension"); 
  209.             YYABORT; 
  210.         }
  211.         actual_dim_count++;
  212.     }
  213. ;
  214.  
  215. pattern_list: pattern
  216.     |     pattern_list pattern
  217. ;
  218.  
  219. pattern: 
  220. {
  221.     if (current_pattern >= no_of_pattern)
  222.     { 
  223.     yyerror("to many patterns"); 
  224.     YYABORT; 
  225.     }
  226. } 
  227. pattern_start 
  228. {
  229.     if (kr_np_GetDescriptor(pattern_set, current_pattern, &pattern)
  230.     != KRERR_NO_ERROR)
  231.     {
  232.     yyerror("pattern parser internal error");
  233.     YYABORT;
  234.     }
  235.     if (next_pattern_is_input)
  236.     {
  237.     pattern -> input_fixsize = no_of_input;
  238.     pattern -> input_dim = variable_input_dim;
  239.     pattern -> output_fixsize = no_of_output;
  240.     pattern -> output_dim = variable_output_dim;
  241.     if (actual_dim_count != variable_input_dim)
  242.     { 
  243.         yyerror("illegal number of entries in dimension list"); 
  244.         YYABORT; 
  245.     }
  246.     act_size = no_of_input;
  247.     for (i=0; i<variable_input_dim; i++)
  248.     {
  249.         if (dims[i] > max_i_dims[i])
  250.         { 
  251.         yyerror("variable dimension overflow"); 
  252.         YYABORT; 
  253.         }
  254.         act_size *= dims[i];
  255.         (pattern -> input_dim_sizes)[i] = dims[i];
  256.     }
  257.     if (kr_np_AllocatePattern(pattern, next_pattern_is_input)
  258.         != KRERR_NO_ERROR)
  259.     { 
  260.         yyerror("can't allocate memory"); 
  261.         YYABORT; 
  262.     }
  263.     pat_mem = pattern -> input_pattern;
  264.     }
  265.     else
  266.     {
  267.     if (actual_dim_count != variable_output_dim)
  268.     { 
  269.         yyerror("illegal number of entries in dimension list"); 
  270.         YYABORT; 
  271.     }
  272.     act_size = no_of_output;
  273.     for (i=0; i<variable_output_dim; i++)
  274.     {
  275.         if (dims[i] > max_o_dims[i])
  276.         { 
  277.         yyerror("variable dimension overflow"); 
  278.         YYABORT; 
  279.         }
  280.         act_size *= dims[i];
  281.         (pattern -> output_dim_sizes)[i] = dims[i];
  282.     }
  283.     if (kr_np_AllocatePattern(pattern, next_pattern_is_input)
  284.         != KRERR_NO_ERROR)
  285.     { 
  286.         yyerror("can't allocate memory"); 
  287.         YYABORT; 
  288.     }
  289.     pat_mem = pattern -> output_pattern;
  290.     }
  291. }
  292. pattern_body 
  293. {
  294.     if (act_size > 0)
  295.     { 
  296.     yyerror("to little values in pattern"); 
  297.     YYABORT; 
  298.     }
  299.     
  300.     if (no_of_output > 0)
  301.     next_pattern_is_input = !next_pattern_is_input;
  302.     
  303.     if (next_pattern_is_input)
  304.     current_pattern++;
  305. }
  306. PATTERNEND
  307. ;
  308.  
  309. pattern_start: actual_dim
  310.         | /* empty */
  311. {
  312.     actual_dim_count = 0;
  313. }
  314. ;
  315.  
  316.  
  317. pattern_body: pattern_entry
  318.     |     pattern_body pattern_entry
  319. ;
  320.  
  321. pattern_entry: NUMBER
  322.     {
  323.         if (act_size == 0)
  324.         { 
  325.             yyerror("to many values in pattern"); 
  326.             YYABORT; 
  327.         }
  328.         *pat_mem++ = $1;
  329.         if (--act_size == 0)
  330.             scanner_await_pattern_end(); 
  331.     }
  332. ;
  333.  
  334.  
  335. %%
  336.  
  337. #ifndef alloca
  338. #ifndef __GNUC__
  339. #ifdef __hpux
  340. /*****************************************************************************
  341.   FUNCTION : alloca
  342.  
  343.   PURPOSE  : must be provided for the parser.
  344.              Uses malloc to allocate memory. This memory is not automatically
  345.              freed as in the original alloca definition 
  346.   RETURNS  : pointer to memory
  347.   NOTES    : This is necessary for HP_UX only since there comes no alloca() 
  348.              with the HP cc C-compiler.
  349.          It is not necessary with Gnu C
  350.  
  351.   UPDATE   : 
  352. ******************************************************************************/
  353. void *alloca(int size)
  354. {
  355.     void *p;
  356.  
  357.     p = malloc(size);
  358.     fprintf(stderr, "warning: malloc called instead of alloca\n");
  359.     return p;
  360. }
  361. #endif /* __hpux */
  362. #endif /* GNU C. not defined  */
  363. #endif /* alloca not defined.  */
  364.  
  365. /*****************************************************************************
  366.   FUNCTION : yyerror
  367.  
  368.   PURPOSE  : must be provided for the parser.
  369.              reports errors in pattern file to stderr
  370.   RETURNS  : nothing
  371.   NOTES    :
  372.  
  373.   UPDATE   : 
  374. ******************************************************************************/
  375. static void yyerror(char *error)
  376. {
  377.     fprintf(stderr, "Parse error in pattern file at line %d:\n%s\n",
  378.         lineno, error);
  379. }
  380.  
  381. /*****************************************************************************
  382.   FUNCTION : parse_pattern_file
  383.  
  384.   PURPOSE  : calls the real parser
  385.  
  386.   RETURNS  : parser error code and the handle to the loaded pattern set
  387.   NOTES    :
  388.  
  389.   UPDATE   : 
  390. ******************************************************************************/
  391. int parse_pattern_file(int *set)
  392. {
  393.     int err;
  394.  
  395.     lineno = 1;
  396.     err = yyparse();
  397.     *set = pattern_set;
  398.  
  399.     if (err == 0)
  400.     lineno = 0;
  401.  
  402.     return err;
  403. }
  404.  
  405. /*****************************************************************************
  406. END OF FILE
  407. ******************************************************************************/
  408.